#include "timeout_manager.hpp"
#include <iostream>
#include <chrono>
#include <thread>
#include <cassert>
#include <string>

using namespace timeout_manager;

// 测试函数：快速完成的任务
int quickTask(int a, int b) {
    std::cout << "执行快速任务: " << a << " + " << b << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    return a + b;
}

// 测试函数：慢速任务
int slowTask(int duration) {
    std::cout << "执行慢速任务，需要 " << duration << "ms" << std::endl;
    std::cout << "慢速任务第一阶段..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(duration/2));
    
    std::cout << "慢速任务第二阶段..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(duration/2));

    std::cout << "慢速任务完成" << std::endl;
    return duration;
}

// 测试函数：无返回值任务
void voidTask(const std::string& message) {
    std::cout << "执行void任务: " << message << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

// 测试函数：抛出异常的任务
int exceptionTask() {
    std::cout << "准备抛出异常的任务" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    throw std::runtime_error("测试异常");
    return 42;
}

void testBasicFunctionality() {
    std::cout << "\n=== 测试基本功能 ===" << std::endl;
    
    // 创建超时管理器（小配置便于测试）
    TimeoutManager manager(2, 60, std::chrono::milliseconds(100));

    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    // 测试正常完成的任务
    {
        std::cout << "\n--- 测试正常任务 ---" << std::endl;
        auto future = manager.executeWithTimeout(
            std::chrono::milliseconds(200),  // 200ms超时
            quickTask, 10, 20
        );
        
        int result = future.get();
        std::cout << "任务结果: " << result << std::endl;
        assert(result == 30);
        std::cout << "✓ 正常任务执行成功" << std::endl;
    }
    
    // 测试超时的任务
    {
        std::cout << "\n--- 测试超时任务 ---" << std::endl;
        auto future = manager.executeWithTimeout(
            std::chrono::milliseconds(100),  // 100ms超时
            slowTask, 300                    // 任务需要300ms
        );
        
        try {
            future.get();
            assert(false);  // 不应该到达这里
        } catch (const TimeoutException& e) {
            std::cout << "✓ 正确捕获超时异常: " << e.what() << std::endl;
        }
    }
    
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    // 测试void返回类型
    {
        std::cout << "\n--- 测试void任务 ---" << std::endl;
        auto future = manager.executeWithTimeout(
            std::chrono::milliseconds(200),
            voidTask, "Hello World"
        );
        
        future.get();  // 等待完成
        std::cout << "✓ void任务执行成功" << std::endl;
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
}

void testExceptionHandling() {
    std::cout << "\n=== 测试异常处理 ===" << std::endl;
    
    TimeoutManager manager(2, 60, std::chrono::milliseconds(100));
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    
    auto future = manager.executeWithTimeout(
        std::chrono::milliseconds(200),
        exceptionTask
    );
    
    try {
        future.get();
        assert(false);  // 不应该到达这里
    } catch (const std::runtime_error& e) {
        std::cout << "✓ 正确捕获任务异常: " << e.what() << std::endl;
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
}

void testAsyncExecution() {
    std::cout << "\n=== 测试异步执行 ===" << std::endl;
    
    TimeoutManager manager(2, 60, std::chrono::milliseconds(100));
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    
    std::atomic<bool> callbackExecuted(false);
    
    // 测试异步执行与回调
    // 注意参数顺序：timeout, func, callback, func_args...
    auto handle = manager.executeWithTimeoutAsync(
        std::chrono::milliseconds(200),
        quickTask,                        // 要执行的函数
        [&callbackExecuted](int result) { // 完成回调
            std::cout << "异步任务完成，结果: " << result << std::endl;
            assert(result == 20);
            callbackExecuted.store(true);
        },
        5, 15                            // 函数参数
    );
    
    std::cout << "异步任务已提交，任务ID: " << handle.getId() << std::endl;
    
    // 等待回调执行
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    
    assert(callbackExecuted.load());
    std::cout << "✓ 异步执行和回调工作正常" << std::endl;

    std::this_thread::sleep_for(std::chrono::milliseconds(300));
}

void testTaskCancellation() {
    std::cout << "\n=== 测试任务取消 ===" << std::endl;
    
    TimeoutManager manager(2, 60, std::chrono::milliseconds(100));
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    
    // 提交一个长时间运行的任务
    auto handle = manager.executeWithTimeoutAsync(
        std::chrono::milliseconds(1000),  // 1秒超时
        slowTask,                         // 函数
        [](int result) {                  // 回调
            std::cout << "这个回调不应该执行!" << std::endl;
            assert(false);
        },
        500                              // 函数参数：500ms任务
    );
    
    std::cout << "任务已提交，ID: " << handle.getId() << std::endl;
    
    // 等待一小段时间后取消
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    
    bool cancelled = manager.cancelTask(handle);
    assert(cancelled);
    std::cout << "✓ 任务取消成功" << std::endl;
    
    // 等待一段时间确保任务确实被取消
    std::this_thread::sleep_for(std::chrono::milliseconds(200));

    std::this_thread::sleep_for(std::chrono::milliseconds(300));
}

void testStatistics() {
    std::cout << "\n=== 测试统计信息 ===" << std::endl;
    
    TimeoutManager manager(2, 60, std::chrono::milliseconds(100));
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    
    // 提交多个不同类型的任务
    std::vector<std::future<int>> futures;
    
    // 正常完成的任务
    for (int i = 0; i < 3; ++i) {
        futures.push_back(manager.executeWithTimeout(
            std::chrono::milliseconds(200),
            quickTask, i, i * 2
        ));
    }
    
    // 超时的任务
    auto timeoutFuture = manager.executeWithTimeout(
        std::chrono::milliseconds(50),   // 很短的超时
        slowTask, 200                    // 较长的任务
    );
    
    // 取消的任务
    auto handle = manager.executeWithTimeoutAsync(
        std::chrono::milliseconds(1000),
        slowTask,                        // 函数
        [](int) {                       // 回调
            std::cout << "不应该执行的回调" << std::endl; 
        },
        800                             // 函数参数
    );
    
    // 等待一小段时间后取消
    std::this_thread::sleep_for(std::chrono::milliseconds(20));
    manager.cancelTask(handle);
    
    // 等待所有正常任务完成
    for (auto& future : futures) {
        future.get();
    }
    
    // 等待超时任务超时
    try {
        timeoutFuture.get();
    } catch (const TimeoutException&) {
        // 预期的超时异常
    }
    
    // 等待一段时间确保所有统计更新完成
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
    
    // 检查统计信息
    auto stats = manager.getStatistics();
    std::cout << "统计信息:" << std::endl;
    std::cout << "  总任务数: " << stats.totalTasks << std::endl;
    std::cout << "  已完成: " << stats.completedTasks << std::endl;
    std::cout << "  超时: " << stats.timeoutTasks << std::endl;
    std::cout << "  取消: " << stats.cancelledTasks << std::endl;
    std::cout << "  活跃: " << stats.activeTasks << std::endl;
    std::cout << "  队列中: " << stats.queuedTasks << std::endl;
    
    assert(stats.totalTasks == 5);      // 3正常 + 1超时 + 1取消
    assert(stats.completedTasks == 3);  // 3个正常任务
    assert(stats.timeoutTasks == 1);    // 1个超时任务
    assert(stats.cancelledTasks == 1);  // 1个取消任务
    
    std::cout << "✓ 统计信息正确" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
}

void testSingletonAccess() {
    std::cout << "\n=== 测试单例访问 ===" << std::endl;
    
    // 通过单例访问
    auto& manager = TimeoutManager::getInstance();
    
    auto future = manager.executeWithTimeout(
        std::chrono::milliseconds(100),
        []() { 
            std::cout << "通过单例执行的任务" << std::endl;
            return 99; 
        }
    );
    
    int result = future.get();
    assert(result == 99);
    std::cout << "✓ 单例访问工作正常" << std::endl;
}

int main() {
    std::cout << "开始测试超时管理器..." << std::endl;
    
    testBasicFunctionality();
    testExceptionHandling();
    testAsyncExecution();
    testTaskCancellation();
    testStatistics();
    testSingletonAccess();
    
    std::cout << "\n所有超时管理器测试通过！" << std::endl;
    std::cout << "系统即将退出，观察资源清理过程..." << std::endl;
    
    return 0;
}